﻿using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using tea.BL;
using tea.DB;
using tea.Models;
using Util;

namespace tea.Controllers
{
    [Authorize]
    public class ResumeController : Controller
    {

        [HttpGet]
        public ActionResult Page1()
        {
            using (var db = new DBDataContext()) {
                var 이력서 = db.이력서.FirstOrDefault(p => p.사용자ID == BL사용자.현재사용자.ID);
                if (이력서 == null) {
                    이력서 = new DB.이력서 { 사용자ID = BL사용자.현재사용자.ID };
                    db.이력서.InsertOnSubmit(이력서);
                    db.SubmitChanges();
                }
                var 모델 = new ResumePage1Model(이력서);
                return View(모델);
            };
        }

        [HttpPost]
        [Util.AjaxOnly]
        public ActionResult SavePage1(ResumePage1Model 모델)
        {
            if (string.IsNullOrWhiteSpace(모델.성별)) return Json(new AjaxFailureModel(Consts.성별미입력));

            using (var db = new DBDataContext()) {
                var 이력서 = db.이력서.First(p => p.사용자ID == BL사용자.현재사용자.ID);
                ResumePage1Model.Copy(from: 모델, to: 이력서);
                if (BL사용자.현재사용자.이름 != 모델.이름 || BL사용자.현재사용자.이메일 != 모델.이메일) {
                    이력서.사용자.이름 = 모델.이름;
                    이력서.사용자.이메일 = 모델.이메일;
                    BL사용자.현재사용자 = 이력서.사용자;
                }
                db.SubmitChanges();
                return Json(Consts.Ajax저장됨);
            }
        }


        [HttpGet]
        public ActionResult Page2()
        {
            return View();
        }

        [Util.AjaxOrChildActionOnly]
        public ActionResult SchoolList()
        {
            using (var db = new DBDataContext()) {
                var 모델 = db.이력서_학력.Where(p => p.사용자ID == BL사용자.현재사용자.ID).ToList();
                if (모델.Count == 0) 모델.Add(new DB.이력서_학력 { ID = 0, 사용자ID = BL사용자.현재사용자.ID });
                return PartialView("_SchoolList", 모델);
            }
        }

        [HttpPost]
        [Util.AjaxOnly]
        public ActionResult School(int id)
        {
            DB.이력서_학력 모델 = null;
            if (id == 0) {
                모델 = new DB.이력서_학력 { 사용자ID = BL사용자.현재사용자.ID };
            } else {
                using (var db = new DBDataContext())
                    모델 = db.이력서_학력.Single(p => p.ID == id);
            }
            return PartialView("_School", 모델);
        }

        [HttpPost]
        [Util.AjaxOnly]
        public ActionResult SaveSchool(DB.이력서_학력 모델)
        {
            using (var db = new DBDataContext()) {
                if (모델.ID > 0) {
                    var data = db.이력서_학력.Single(p => p.ID == 모델.ID);
                    BeanUtil.속성복사(모델, data);
                } else {
                    db.이력서_학력.InsertOnSubmit(모델);
                }
                db.SubmitChanges();
                return Json(Consts.Ajax조용한성공);
            }
        }

        [HttpPost]
        [Util.AjaxOnly]
        public ActionResult DeleteSchool(int id)
        {
            using (var db = new DBDataContext()) {
                db.이력서_학력.DeleteAllOnSubmit(db.이력서_학력.Where(p => p.ID == id));
                db.SubmitChanges();
            }
            return Json(Consts.Ajax조용한성공);
        }

        [Util.AjaxOrChildActionOnly]
        public ActionResult LectureList(int type)
        {
            using (var db = new DBDataContext()) {
                var 모델 = db.이력서_경력.Where(p => p.사용자ID == BL사용자.현재사용자.ID && p.구분 == type).ToList();
                if (모델.Count == 0) 모델.Add(new DB.이력서_경력 { ID = 0, 사용자ID = BL사용자.현재사용자.ID, 구분 = type });
                return PartialView("_LectureList", 모델);
            }
        }

        [HttpPost]
        [Util.AjaxOnly]
        public ActionResult Lecture(int id, int type)
        {
            DB.이력서_경력 모델 = null;
            if (id == 0) {
                모델 = new DB.이력서_경력 { 사용자ID = BL사용자.현재사용자.ID, 구분 = type };
            } else {
                using (var db = new DBDataContext())
                    모델 = db.이력서_경력.Single(p => p.ID == id);
            }
            return PartialView("_Lecture", 모델);
        }

        [HttpPost]
        [Util.AjaxOnly]
        public ActionResult SaveLecture(DB.이력서_경력 모델)
        {
            using (var db = new DBDataContext()) {
                if (모델.ID > 0) {
                    var data = db.이력서_경력.Single(p => p.ID == 모델.ID);
                    BeanUtil.속성복사(모델, data);
                } else {
                    db.이력서_경력.InsertOnSubmit(모델);
                }
                db.SubmitChanges();
                return Json(Consts.Ajax조용한성공);
            }
        }

        [HttpPost]
        [Util.AjaxOnly]
        public ActionResult DeleteLecture(int id)
        {
            using (var db = new DBDataContext()) {
                db.이력서_경력.DeleteAllOnSubmit(db.이력서_경력.Where(p => p.ID == id));
                db.SubmitChanges();
            }
            return Json(Consts.Ajax조용한성공);
        }

        [Util.AjaxOrChildActionOnly]
        public ActionResult PaperList()
        {
            using (var db = new DBDataContext()) {
                var 모델 = db.이력서_논문.Where(p => p.사용자ID == BL사용자.현재사용자.ID).ToList();
                if (모델.Count == 0) 모델.Add(new DB.이력서_논문 { ID = 0, 사용자ID = BL사용자.현재사용자.ID });
                return PartialView("_PaperList", 모델);
            }
        }

        [HttpPost]
        [Util.AjaxOnly]
        public ActionResult Paper(int id)
        {
            DB.이력서_논문 모델 = null;
            if (id == 0) {
                모델 = new DB.이력서_논문 { 사용자ID = BL사용자.현재사용자.ID };
            } else {
                using (var db = new DBDataContext())
                    모델 = db.이력서_논문.Single(p => p.ID == id);
            }
            return PartialView("_Paper", 모델);
        }

        [HttpPost]
        [Util.AjaxOnly]
        public ActionResult SavePaper(DB.이력서_논문 모델)
        {
            using (var db = new DBDataContext()) {
                if (모델.ID > 0) {
                    var data = db.이력서_논문.Single(p => p.ID == 모델.ID);
                    BeanUtil.속성복사(모델, data);
                } else {
                    db.이력서_논문.InsertOnSubmit(모델);
                }
                db.SubmitChanges();
                return Json(Consts.Ajax조용한성공);
            }
        }

        [HttpPost]
        [Util.AjaxOnly]
        public ActionResult DeletePaper(int id)
        {
            using (var db = new DBDataContext()) {
                db.이력서_논문.DeleteAllOnSubmit(db.이력서_논문.Where(p => p.ID == id));
                db.SubmitChanges();
            }
            return Json(Consts.Ajax조용한성공);
        }

        [HttpGet]
        public ActionResult Page3()
        {
            using (var db = new DBDataContext()) {
                var 이력서 = db.이력서.Single(p => p.사용자ID == BL사용자.현재사용자.ID);
                return View(이력서);
            };
        }

        [HttpPost]
        [Util.AjaxOnly]
        public ActionResult SavePage3(DB.이력서 모델)
        {
            using (var db = new DBDataContext()) {
                var 이력서 = db.이력서.Single(p => p.사용자ID == BL사용자.현재사용자.ID);
                이력서.논문제목 = 모델.논문제목;
                이력서.논문요약 = 모델.논문요약;
                db.SubmitChanges();
                return Json(Consts.Ajax저장됨);
            }
        }

        [HttpGet]
        public ActionResult Page4()
        {
            using (var db = new DBDataContext()) {
                var 이력서 = db.이력서.Single(p => p.사용자ID == BL사용자.현재사용자.ID);
                var 모델 = new ResumePage4Model {
                    사진파일 = db.파일첨부.Where(p => p.대상ID == BL사용자.현재사용자.ID && p.대상유형 == BL파일.파일첨부_이력서사진).OrderByDescending(p => p.ID).FirstOrDefault(),
                    학위파일 = db.파일첨부.Where(p => p.대상ID == BL사용자.현재사용자.ID && p.대상유형 == BL파일.파일첨부_이력서학위증).OrderByDescending(p => p.ID).FirstOrDefault()
                };
                return View(모델);
            }
        }

        [HttpGet]
        [Authorize(Roles = BL사용자.ADMIN_OR_STAFF)]
        public ActionResult List(PaginationModel pagination)
        {
            string 키 = "ResumeList" + pagination.ID;
            ViewState.Load(키, pagination, PaginationModel.DEFAULT);

            using (var db = new DBDataContext())
            {
                var list = db.이력서.Where(p => true);

                // 채용
                if (pagination.ID > 0)
                    list = list.Where(p => db.지원.Any(t => t.사용자ID == p.사용자ID && t.채용ID == pagination.ID));

                // 검색
                if (pagination.srchType == BL이력서.검색_없음 ||
                     (Request.Url.Query.IndexOf("srchText") > 0 && string.IsNullOrWhiteSpace(Request.QueryString["srchText"])))
                {
                    pagination.srchType = BL이력서.검색_없음;
                    pagination.srchText = null;
                }
                else
                {
                    switch (pagination.srchType)
                    {
                        case BL이력서.검색_이름: list = list.Where(p => p.사용자.이름.Contains(pagination.srchText)); break;
                        case BL이력서.검색_학위: list = list.Where(p => p.이력서_학력.Any(q => q.구분 == pagination.srchText || q.학교명.Contains(pagination.srchText) || q.학과.Contains(pagination.srchText) || q.전공.Contains(pagination.srchText))); break;
                        case BL이력서.검색_경력: list = list.Where(p => p.이력서_경력.Any(q => q.기관.Contains(pagination.srchText) || q.내용.Contains(pagination.srchText))); break;
                        default: Debug.Assert(false); break;
                    }
                }

                // 정렬
                switch (pagination.order.Value) {
                    case BL이력서.정렬_회원등록: list = list.OrderByDescending(p => p.사용자ID); break;
                    case BL이력서.정렬_이름: list = list.OrderBy(p => p.사용자.이름); break;
                    case BL이력서.정렬_생년월일: list = list.OrderBy(p => p.생년월일); break;
                    default: Debug.Assert(false); break;
                }

                // 현재 페이지
                pagination.pageCount = (int)Math.Ceiling((double)list.Count() / (double)pagination.size);
                pagination.page = Math.Max(1, Math.Min(pagination.page.Value, pagination.pageCount.Value));
                pagination.url = Url.ResumeList(new PaginationModel { ID = pagination.ID, page = 989898 }).Replace("989898", "{0}");

                var 이력서목록 = list.Skip((pagination.page.Value - 1) * pagination.size.Value).Take(pagination.size.Value);
                var 모델 = new ResumeListModel
                {
                    pagination = pagination,
                    요약목록 = BL이력서.이력서요약목록(이력서목록)
                };
                ViewState.Save(키, pagination);
                return View("List", 모델);
            }
        }

        [HttpGet]
        public ActionResult ApplicationList(PaginationModel pagination)
        {
            if (pagination.ID == null || pagination.ID == 0) {
                using (var db = new DBDataContext()) {
                    var data = db.채용.OrderByDescending(p => p.ID).FirstOrDefault();
                    if (data == null) return View("_Redirect", new ErrorModel(Consts.지원기간아님, Url.Action("List", "Recruit")));
                    pagination.ID = data.ID;
                }
            }
            return List(pagination);
        }
    }
}
